import axios, { AxiosInstance, InternalAxiosRequestConfig, AxiosResponse } from 'axios'
import { message } from 'ant-design-vue'
import router from '@/router'  // 直接导入router实例，而不是useRouter()

// 创建统一的API实例，通过网关访问所有服务
const request: AxiosInstance = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL || 'http://localhost:9000', // 网关地址
  timeout: 15000,
  withCredentials: true,
  headers: {
    'Content-Type': 'application/json'
  }
})

// // API响应数据格式（认证服务和帖子服务）
// interface CommonApiResponse<T = any> {
//   code: number | string
//   message: string
//   data: T
//   success: boolean
// }

// // 用户服务的响应格式
// interface UserApiResponse<T = any> {
//   code: string
//   message: string
//   data: T
//   success?: boolean
// }

// 配置请求拦截器
request.interceptors.request.use(
  (config: InternalAxiosRequestConfig) => {
    // 添加认证头
    const token = localStorage.getItem('accessToken')
    if (token && config.headers) {
      // 确保token格式正确，避免多余空格
      const formattedToken = token.startsWith('Bearer ') ? token : `Bearer ${token}`
      config.headers['Authorization'] = formattedToken
      
      // 打印请求信息（隐藏完整token）
      const maskedToken = token.length > 10 ? 
        `${token.substring(0, 5)}...${token.substring(token.length - 5)}` : '***'
      console.log(`[请求] ${config.method?.toUpperCase()} ${config.url}`, 
        `Auth: Bearer ${maskedToken}`, 
        config.params || config.data)
    } else if (config.url && !config.url.includes('/auth/login')) {
      console.warn(`[请求警告] 没有授权令牌: ${config.url}，可能导致认证失败`)
    }
    
    return config
  },
  (error: any) => {
    console.error('[请求错误]', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
request.interceptors.response.use(
  (response: AxiosResponse) => {
    // 日志输出响应基本信息
    console.log(`[响应] ${response.config.url} - 状态: ${response.status}`)
    
    // 如果响应是文件流，直接返回
    if (response.config.responseType === 'blob') {
      return response
    }

    const res = response.data
    
    // 详细记录响应内容用于调试
    if (res && typeof res === 'object') {
      // 记录响应数据的结构，帮助调试格式不一致问题
      console.log(`[响应结构] URL: ${response.config.url}, 字段:`, Object.keys(res));
      
      // 特别关注用户相关的API响应
      if (response.config.url?.includes('user') || response.config.url?.includes('login')) {
        // 不记录敏感数据，只记录结构
        const sanitizedData = { ...res };
        if (sanitizedData.data && typeof sanitizedData.data === 'object') {
          sanitizedData.data = '包含用户数据';
        }
        console.log(`[用户API响应] ${response.config.url}:`, sanitizedData);
        
        // 确保类型一致性 - 将字符串类型的id转换为数字
        if (res.data && typeof res.data === 'object') {
          if (res.data.id !== undefined && typeof res.data.id === 'string') {
            res.data.id = parseInt(res.data.id);
            console.log(`[类型转换] ${response.config.url} - 将data.id从字符串转为数字: ${res.data.id}`);
          }
          
          // 自动解析title字段
          if (res.data.title && typeof res.data.title === 'string') {
            try {
              // 检查是否是JSON字符串
              if (res.data.title.startsWith('[') && res.data.title.endsWith(']')) {
                res.data.title = JSON.parse(res.data.title);
                console.log('[数据处理] 已将title从JSON字符串解析为数组');
              }
            } catch (e) {
              console.warn('[数据处理] 解析title字段失败:', e);
              // 保持原始字符串
            }
          }
        }
      }
      
      // 统一处理code字段类型
      if (res.code !== undefined) {
        // 转换code为数字类型用于比较
        if (typeof res.code === 'string') {
          res.code = parseInt(res.code);
          console.log(`[类型转换] ${response.config.url} - 将code从字符串转为数字: ${res.code}`);
        }
      }
    }

    // 处理不同服务的响应格式
    if (res.code !== undefined) {
      // 确保code是数字类型用于比较
      const codeNum = typeof res.code === 'number' ? res.code : parseInt(String(res.code));
      
      // 统一判断成功状态 - 确保用一致的逻辑判断
      const isSuccess = codeNum === 200 || codeNum === 0 || res.success === true;

      if (isSuccess) {
        console.log(`[响应成功] ${response.config.url} - 返回完整响应`);
        return res;
      }

      // 处理特定错误码
      console.error(`[响应错误] ${response.config.url} - 代码: ${codeNum}, 消息: ${res.message}`);
      
      switch (codeNum) {
        case 401:
          message.error('登录已过期，请重新登录');
          // 清理所有登录相关状态
          localStorage.removeItem('accessToken');
          localStorage.removeItem('refreshToken');
          localStorage.removeItem('userInfo');
          localStorage.removeItem('isLoggedIn');
          
          console.warn('[登录过期] 已清除所有登录状态');
          
          // 延迟重定向，让用户看到提示
          setTimeout(() => {
            // 获取当前路径，用于登录后返回
            const currentPath = window.location.pathname;
            const redirectParam = currentPath !== '/login' ? `?redirect=${encodeURIComponent(currentPath)}` : '';
            window.location.href = `/login${redirectParam}`;
          }, 1500);
          break;
        case 403:
          message.error('没有权限进行此操作');
          break;
        case 500:
          // 检查是否是登录请求
          if (response.config.url?.includes('login') || response.config.url?.includes('auth')) {
            // 登录相关的500错误，直接视为账号密码错误
            console.log('[登录错误] 检测到账号密码验证失败');
            message.error('账号或密码错误');
            
            // 创建一个新的错误对象并标记为已处理，这样在上层代码中可以避免重复显示错误
            const handledError = new Error('账号或密码错误');
            (handledError as any).isHandled = true;
            return Promise.reject(handledError);
          } else {
            message.error('服务器错误，请稍后重试');
            // 标记其他500错误也为已处理
            const serverError = new Error('服务器错误，请稍后重试');
            (serverError as any).isHandled = true;
            return Promise.reject(serverError);
          }
          break;
        default:
          message.error(res.message || '操作失败');
      }

      return Promise.reject(new Error(res.message || '操作失败'));
    }
    
    // 如果没有标准响应格式但有数据，则直接返回
    console.log(`[响应] ${response.config.url} - 非标准格式，直接返回数据`);
    return res;
  },
  (error: any) => {
    console.error('[响应错误]', error);
    
    // 打印更详细的错误信息便于调试
    if (error.response && error.response.data) {
      console.error('[详细错误信息]', error.response.data);
    }
    
    const response = error.response;
    
    // 添加CORS错误的特殊处理
    if (error.message === 'Network Error') {
      console.error('[网络错误] 可能是CORS配置问题');
      message.error('网络错误：可能是跨域配置问题，请检查服务器配置');
      (error as any).isHandled = true;
      return Promise.reject(error);
    }
    
    if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
      console.error('[请求超时]', error);
      message.error('请求超时，请检查您的网络连接');
      (error as any).isHandled = true;
      return Promise.reject(error);
    }

    if (response && response.status) {
      switch (response.status) {
        case 401:
          console.error('[未授权] 401', response);
          message.error('登录已过期，请重新登录');
          
          // 延迟跳转登录页面
          setTimeout(() => {
            router.push('/login');
          }, 1500);
          (error as any).isHandled = true;
          break;
        case 403:
          console.error('[禁止访问] 403', response);
          message.error('您没有权限访问此资源');
          (error as any).isHandled = true;
          break;
        case 404:
          console.error('[资源不存在] 404', response);
          message.error('请求的资源不存在');
          (error as any).isHandled = true;
          break;
        case 500:
          console.error('[服务器错误] 500', response);
          
          // 登录错误处理 - 特殊处理
          if (error.config.url.includes('/login')) {
            console.log('登录失败：账号或密码错误');
            const newError = new Error('账号或密码错误');
            (newError as any).isHandled = true;
            return Promise.reject(newError);
          }
          
          // 处理其他500错误
          message.error(`服务器错误 (${response.status}): ${response.data?.message || '请稍后再试'}`);
          (error as any).isHandled = true;
          break;
        default:
          console.error(`[请求错误] ${response.status}`, response);
          message.error(`请求失败 (${response.status}): ${response.data?.message || '未知错误'}`);
          (error as any).isHandled = true;
      }
    } else {
      // 处理无响应错误
      console.error('[无响应错误]', error);
      message.error('网络连接错误，请检查您的网络状态');
      (error as any).isHandled = true;
    }
    
    return Promise.reject(error);
  }
)

export default request